package com.elh.nio;

import org.junit.jupiter.api.Test;

import java.nio.CharBuffer;

/**
 * @author liulei
 **/
public class Test1 {


    @Test
    public void demo1(){
        char[] chars = new char[]{'a', 'b', 'c', 'd'};
        CharBuffer buffer = CharBuffer.wrap(chars);
        // 4:缓存区容量
        System.out.println(buffer.capacity());
        // 从0开始的指向下一个开始的位置:缓存区限制:只有limit的元素的之前的数据才可以读取和写入
        System.out.println(buffer.limit());
        // 缓存区的位置,下一个存储元素或者读取元素的位置
        System.out.println(buffer.position());
    }

    /**
     * 测试limit限制写入
     */
    @Test
    public void demo2(){
        char[] chars = new char[]{'a', 'b', 'c', 'd'};
        CharBuffer buffer = CharBuffer.wrap(chars);
        // limit那么0,1,2的位置才可以写入数据
        buffer.limit(3);
        // java.lang.IndexOutOfBoundsException
        buffer.put(3,'r');
    }


    /**
     * remaining():返回当前位置与limit之前的元素数
     *
     */
    @Test
    public void demo3(){
        char[] chars = new char[]{'a', 'b', 'c', 'd'};
        CharBuffer buffer = CharBuffer.wrap(chars);
        // limit那么0,1,2的位置才可以写入数据
        buffer.limit(3);
        // position < limit
        buffer.hasRemaining();
        // limit - position: 当前位置与Limit之前的元素数
        // limit = 3 ,position = 0
        System.out.println(buffer.remaining());
    }


    /**
     * 测试mark
     *
     */
    @Test
    public void demo4(){
        char[] chars = new char[]{'a', 'b', 'c', 'd'};
        CharBuffer buffer = CharBuffer.wrap(chars);
        buffer.position(1);
        buffer.mark();
        System.out.println(buffer.position());
        // 改变位置
        buffer.position(2);
        System.out.println(buffer.position());
        // 位置重置回到1
        buffer.reset();
        System.out.println(buffer.position());
        System.out.println(buffer.isReadOnly());
        // 直接缓存区
        System.out.println(buffer.isDirect());
    }


    /**
     * 还原缓存区状态
     *
     */
    @Test
    public void demo5(){
        char[] chars = new char[]{'a', 'b', 'c', 'd'};
        CharBuffer buffer = CharBuffer.wrap(chars);
        buffer.position(2);

        /**
         * position = 0;
         * limit = capacity;
         * mark = -1;
         */
        // 回到最开始的状态,"一切默认"
        // 主要是对缓存区数据写入前调用该方法
        // 注意:该方法不能清空缓存区只是写入的时候覆盖原值
        buffer.clear();
    }


    /**
     * flip反转
     *
     */
    @Test
    public void demo6(){
        char[] chars = new char[]{'a', 'b', 'c', 'd'};
        CharBuffer buffer = CharBuffer.wrap(chars);
        buffer.position(2);
        /*
        limit = position;
        position = 0;
        mark = -1;
        */
        // limit给值为position,position = 0
        // 用于写入了数据然后读取数据
        buffer.flip();
    }

    // buffer.arrayOffset()

    /**
     * 返回缓存区数组中底层第一个元素
     *
     */
    @Test
    public void demo7(){
        char[] chars = new char[]{'a', 'b', 'c', 'd'};
        CharBuffer buffer = CharBuffer.wrap(chars);
        buffer.position(2);
        // limit给值为position,position = 0
        // 用于写入了数据然后读取数据
        // super(-1, off, off + len, buf.length, buf, 0);
        buffer.arrayOffset();
    }






}


